#include "FUSE_Functions.h"

int buscarArchivo(char*rutaArchivo,datosArchivo*data){

	fat32_directory *directorio,*ptr=	NULL;
	char*vecAux;
directorio=malloc(sizeof(fat32_directory));
	int pos=0,tamanioPath=0,posAnt=0,i;
	directorio->tipo=0;
	
	for(i=0;rutaArchivo[i]!='.'&&i<strlen(rutaArchivo);i++);
//	if(i<strlen(rutaArchivo))
	//	memcpy((rutaArchivo+i)," ",1);
	tamanioPath=strlen(rutaArchivo);

	pos=strcspn(rutaArchivo,"/");
	posAnt=pos+1;
	leerDirectorio(directorio,FAT32.numClusterDirRoot);
	pos=strcspn(rutaArchivo+posAnt,"/");

	vecAux=malloc(sizeof(char)*pos+1);
	strncpy(vecAux,rutaArchivo+posAnt,pos);
	vecAux[pos]='\0';
    pos+=posAnt;
	
if(directorio->tipo==0)
return 3;
ptr=directorio;
	while(ptr!=NULL&&((strncmp(ptr->nombre,vecAux,pos-1))!=0||strlen(ptr->nombre)!=strlen(vecAux)))
		ptr=ptr->sig;

	free(vecAux);

	if(ptr==NULL)
		return 1;

	else{

			while(pos<tamanioPath){
				posAnt=pos+1;

				if(ptr->tipo!=DIRECTORIO)
					return 1; //no puede haber un dir en un archivo
				free(directorio);
				directorio=malloc(sizeof(fat32_directory));
				directorio->tipo=0;
				leerDirectorio(directorio,ptr->numClusterInicial);

				pos=strcspn(rutaArchivo+posAnt,"/");
				if(pos>tamanioPath)
					return 1; //falla el parseo
				vecAux=malloc(pos);
				strncpy(vecAux,rutaArchivo+posAnt,pos);
				vecAux[pos]='\0';
				
if(directorio->tipo==0)
return 3;
ptr=NULL;
	ptr=	directorio;
	while(ptr!=NULL&&((strncmp(ptr->nombre,vecAux,pos))!=0||strlen(ptr->nombre)!=strlen(vecAux)))
					ptr=ptr->sig;

				if(ptr==NULL)
					return 1;

				pos+=posAnt;
				free(vecAux);
			}
if(ptr->tipo==0)
return 3;
			data->numCluster=ptr->numClusterInicial;
			data->tipo=ptr->tipo;
			data->tamanioArchivo=ptr->tamanio;
			data->sectorEntrada=ptr->numSectorEntrada;
			data->offset=ptr->offsetEntrada;
			data->longfn=ptr->LongFN;
return 0;
	}



}


/*____________________________________________________*/

int leerDatos(datosArchivo*data,char*buffer,int offset,int size){

	int indice,secXcluster,offsetCluster,sector=0;

	static listaClusters*ptr;int off=0;
	//cadenaClusters=malloc(sizeof(listaClusters));
//	cadenaClusters->numCluster=0;
	ptr=data->lista;
	offsetCluster=0;
	static int clusters=0;
	//if(data->tamanioArchivo<offset+size)
	//	size= data->tamanioArchivo -offset;
	//if(offset>=data->tamanioArchivo)
	//	return 0;
	if(fmod (offset,FAT32.tamanioSector) ==0){

			clusters	=(offset/FAT32.tamanioSector)/FAT32.sectoresPorCluster;
				while(clusters>1){
					ptr=ptr->sig;
					clusters--;
				}
				if(FAT32.sectoresPorCluster*FAT32.tamanioSector>offset&&(offset%1024==0))
					offsetCluster=offset/FAT32.tamanioSector;
				else{
								off=offset;
								while(off>0){
								off-=FAT32.tamanioSector;
								offsetCluster++;
								}
								if(offsetCluster>=FAT32.sectoresPorCluster)
									while(offsetCluster>=FAT32.sectoresPorCluster){
										offsetCluster-=8;
										sector++;
									}
							}
			}


			else{
			off=offset;
				while(off>0){
				off-=FAT32.tamanioSector;
				offsetCluster++;
				}

			}

	int offs=0;
			if(offsetCluster%2!=0){
				offs=512;
				//offsetCluster=offsetCluster/2;

			}
	if(clusters>0)
	ptr=ptr->sig;
	if(tamanioCache!=0){
		for(indice=0,secXcluster=0;indice<size;indice+=FAT32.tamanioSector*2,secXcluster+=2){
			if (ptr==NULL)
									return indice;
			if(secXcluster==FAT32.sectoresPorCluster){
						ptr=ptr->sig;
						secXcluster=0;
					}
			if (ptr==NULL)
					return indice;
					int pos=buscarEnCache(data->cacheArchivo, (calcularPrimerSectorDelCluster(ptr->numCluster)+offsetCluster+secXcluster)/2);
					if(pos>=0)
						memcpy(data->cacheArchivo.contCache[pos].contenido,buffer+indice,FAT32.tamanioSector*2);
					else{
						realizar_pedido_lectura((calcularPrimerSectorDelCluster(ptr->numCluster)+offsetCluster+secXcluster)/2,buffer+indice);
						if(offset<tamanioCache*1024)
							 agregarEnCache(data->cacheArchivo,buffer+indice,(calcularPrimerSectorDelCluster(ptr->numCluster)+offsetCluster+secXcluster)/2);
					}
					offsetCluster=0;
				}


	}
	else{
		for(indice=0,secXcluster=0;indice<size;indice+=FAT32.tamanioSector*2,secXcluster+=2){
			if (ptr==NULL)
												return indice;

			if(secXcluster==FAT32.sectoresPorCluster){
				ptr=ptr->sig;
				secXcluster=0;
			}
			if (ptr==NULL)
												return indice;

		int res	=realizar_pedido_lectura((calcularPrimerSectorDelCluster(ptr->numCluster)+offsetCluster+secXcluster+(sector*8))/2,buffer+indice);
		secXcluster+=offsetCluster;
			offsetCluster=0;
		}
	}
	return indice;

}

/*____________________________________________________*/

int escribirArchivo(char *rutaArchivo,datosArchivo*data,const char*buffer,int offset,int size){
int sector=0;
	int indice,secXcluster,offsetCluster,cantClustersFaltantes,sect;
		listaClusters *cadenaClusters=NULL;
		static listaClusters*ptr;
		cadenaClusters=malloc(sizeof(listaClusters));
		cadenaClusters->numCluster=0;
		offsetCluster=0;
		ptr=data->lista;
		int clusters=0;
		int off=0;

		if(fmod (offset,FAT32.tamanioSector) ==0){
			clusters=(offset/FAT32.tamanioSector)/FAT32.sectoresPorCluster;
				while(clusters>1){
					ptr=ptr->sig;
					clusters--;
				}
				if(FAT32.sectoresPorCluster*FAT32.tamanioSector>offset&&(offset%1024==0))
							offsetCluster=offset/FAT32.tamanioSector;
				else{
				off=offset;
				while(off>0){
				off-=FAT32.tamanioSector;
				offsetCluster++;
				}
				if(offsetCluster>=FAT32.sectoresPorCluster)
					while(offsetCluster>=FAT32.sectoresPorCluster&&ptr!=NULL){
						offsetCluster-=8;
						sector++;
					}
			}
		}
			else{
				off=offset;
				while(off>0){
				off-=FAT32.tamanioSector;
				offsetCluster++;}
			}

		if(data->cantClusters*FAT32.tamanioSector*FAT32.sectoresPorCluster< size+offset){
			if(ptr!=NULL)
			cantClustersFaltantes=calcularTamanioNuevo(offsetCluster,ptr->sig,size);
			else
				cantClustersFaltantes=calcularTamanioNuevo(offsetCluster,NULL,size);
		}
		else
			cantClustersFaltantes=0;
		if(clusters==0&&size<512*8 &&offsetCluster==0)
			cantClustersFaltantes=0;
		if(cantClustersFaltantes>0){
			down(mutexFAT);
			if(numClustersLibres<cantClustersFaltantes){
				up(mutexFAT);
				return (-ENOSPC);
			}
			up(mutexFAT);
			int vectorLibres[cantClustersFaltantes];
			if(buscar_Clusters_libres(cantClustersFaltantes,vectorLibres)!=0)
				return (-EIO);


			else{
				if(ptr!=NULL)
				while(ptr->sig!=NULL)
					ptr=ptr->sig;
				data->cantClusters+=cantClustersFaltantes;
				if(cantClustersFaltantes>1){
					grabar_FAT(ptr->numCluster,vectorLibres[0]);
					grabar_FAT(vectorLibres[0],vectorLibres[1]);
					agregarCluster(&(vectorLibres[0]),ptr);
					for(indice=1;indice<cantClustersFaltantes-1;indice++){
						agregarCluster(&(vectorLibres[indice]),ptr);
						grabar_FAT(vectorLibres[indice],vectorLibres[indice+1]);
					}
					agregarCluster(&(vectorLibres[indice]),ptr);
					grabar_FAT(vectorLibres[indice],0xFFFFFFF);
				}
				else{
					grabar_FAT(ptr->numCluster,vectorLibres[0]);
					grabar_FAT(vectorLibres[0],0xFFFFFFF);
					agregarCluster(&(vectorLibres[0]),ptr);
				}
			}
		}
		int offs=0;
		if(offsetCluster%2!=0){
			offs=512;
			//offsetCluster=offsetCluster/2;

		}
		while(sector>0){
			ptr=ptr->sig;
			sector--;
		}
		if(clusters>0&&ptr->sig!=NULL)
			ptr=ptr->sig;
		if(tamanioCache>0){
			for(indice=0,secXcluster=0;indice<size;indice+=FAT32.tamanioSector*2,secXcluster+=2){
				if(secXcluster>=FAT32.sectoresPorCluster){
					ptr=ptr->sig;
					secXcluster=0;
				}
				if((size-indice)>=1024)
					agregarEnCache(data->cacheArchivo,buffer+indice,(calcularPrimerSectorDelCluster(ptr->numCluster)+offsetCluster+offs+secXcluster+(sector*8))/2);
				else{
					char miniBuff[1024];
					memset(miniBuff,0,1024);
					memcpy(miniBuff,buffer+indice,size-indice);
					agregarEnCache(data->cacheArchivo,miniBuff,(calcularPrimerSectorDelCluster(ptr->numCluster)+offs+offsetCluster+secXcluster)/2);
				}

				offsetCluster=0;
			}
		}
		else{
			for(indice=0,secXcluster=0;indice<size;indice+=FAT32.tamanioSector*2,secXcluster+=2){
						if(secXcluster>=FAT32.sectoresPorCluster){
							ptr=ptr->sig;
							secXcluster=0;
						}
						sect=calcularPrimerSectorDelCluster(ptr->numCluster);
						if((size-indice)>=1024)
							realizar_pedido_escritura((sect+offsetCluster+secXcluster)/2,buffer+indice);

						else{
							char miniBuff[1024];
							memset(miniBuff,0,1024);
							memcpy(miniBuff,buffer+indice,size-indice);
							memset(miniBuff+indice+size-indice,0,1024-size);
							realizar_pedido_escritura((calcularPrimerSectorDelCluster(ptr->numCluster)+offsetCluster+secXcluster)/2,miniBuff);
						}

						secXcluster+=offsetCluster;
						offsetCluster=0;
					}
		}

		if(((size>data->tamanioArchivo)&&(offset!=0))||((offset!=0)&&offset>=data->tamanioArchivo)||((size<data->tamanioArchivo)&&(offset!=0))){
			grabarEntradaArchivo(rutaArchivo,size+data->tamanioArchivo+(data->tamanioArchivo-offset));
			data->tamanioArchivo=size+data->tamanioArchivo+(data->tamanioArchivo-offset);
		}
		else{
			grabarEntradaArchivo(rutaArchivo,size);
			data->tamanioArchivo=size;
		}
			return size;
	}

/*____________________________________________________*/

 int calcularTamanioNuevo(int desplazamientoCluster,listaClusters*cadenaClusters,int size){

	int indice=0,resultado;
	listaClusters*ptr=NULL;
	ptr=cadenaClusters;

	for(indice=0;ptr!=NULL;indice++)
		ptr=ptr->sig;
	resultado =   (indice * FAT32.sectoresPorCluster)- desplazamientoCluster;
	int resul=0;
	resul=resultado;
	resultado= (resultado*FAT32.tamanioSector )- size;

	if(resultado>0)
		return (-EINVAL);
	else{
		resul= size- (resul*FAT32.tamanioSector);
		if((fmod(resul,FAT32.tamanioSector)!=0)||(size<(FAT32.tamanioSector*FAT32.sectoresPorCluster)))
			return ((((resul /FAT32.tamanioSector))/FAT32.sectoresPorCluster)+1);
		else
			return ((((resul /FAT32.tamanioSector))/FAT32.sectoresPorCluster));
		}
}

 /*____________________________________________________*/

 int grabarEntradaArchivo(char*rutaArchivo,int nuevoTamanio){


	 fat32_directory* directorio,*ptr=NULL;
	 char*vecAux;
	 int pos,i,tamanioPath,posAnt;
	 directorio=malloc(sizeof(fat32_directory));
	 directorio->tipo=0;

	for(i=0;rutaArchivo[i]!='.'&&i<strlen(rutaArchivo);i++);
	//	if(i<strlen(rutaArchivo))
		//	memcpy((rutaArchivo+i)," ",1);
	tamanioPath=strlen(rutaArchivo);

	pos=strcspn(rutaArchivo,"/");
	posAnt=pos+1;
	leerDirectorio(directorio,FAT32.numClusterDirRoot);
 	pos=strcspn(rutaArchivo+posAnt,"/");

	vecAux=malloc(sizeof(char)*pos);
	strncpy(vecAux,rutaArchivo+posAnt,pos);
	pos+=posAnt;
	ptr=directorio;
	if(directorio->tipo==0)
		return 1;

	while(ptr!=NULL&&(strncmp(ptr->nombre,vecAux,pos-1)!=0))
		ptr=ptr->sig;

	free(vecAux);

	if(ptr==NULL)
		return -ENOENT;

	else{

	 	while(pos<tamanioPath){
	 		posAnt=pos+1;

	 		if(ptr->tipo!=DIRECTORIO)
	 			return -EFAULT; //no puede haber un dir en un archivo
	 		free(directorio);
	 		directorio=malloc(sizeof(fat32_directory));
	 		directorio->tipo=0;
	 		leerDirectorio(directorio,ptr->numClusterInicial);

	 		pos=strcspn(rutaArchivo+posAnt,"/");
	 		if(pos>tamanioPath)
	 			return -ESPIPE; //falla el parseo
	 		vecAux=malloc(sizeof(char)*pos);
	 		strncpy(vecAux,rutaArchivo+posAnt,pos);

	 		ptr=directorio;
	 		if(directorio->tipo==0)
	 			return 1;
	 		while(ptr!=NULL&&(0!=strncmp(ptr->nombre,vecAux,pos)))
	 			ptr=ptr->sig;

	 		if(ptr==NULL)
	 			return 1;

	 		pos+=posAnt;
	 		free(vecAux);
	 	}
 		char bufferEscritura[1024];

 		realizar_pedido_lectura(ptr->numSectorEntrada/2,bufferEscritura);
 		if(ptr->LongFN)
 			ptr->offsetEntrada+=32;
 		if(ptr->numSectorEntrada>ptr->numSectorEntrada/2+ptr->numSectorEntrada/2)
 			ptr->offsetEntrada+=512;

 		memcpy(bufferEscritura+ptr->offsetEntrada+0x1C,&nuevoTamanio,sizeof(uint32_t));
 		realizar_pedido_escritura(ptr->numSectorEntrada/2,bufferEscritura);
 	}

 	return 0;
 }

 /*____________________________________________________*/

 int crearArchivoDirectorio(char* rutaArchivo,datosArchivo*data,mode_t modoApertura,int creacion){

	 int offset=0;
	 int sectorIni=0;
	 int numCluster=0;
	 int indice,i;
	 datosArchivo* dataLocal=malloc(sizeof(datosArchivo));

	 indice=strlen(rutaArchivo);

		 for(i=0;rutaArchivo[indice]!='/';indice--,i++);
		 char nombre[13];
		 memset(nombre,0,13);

		 memcpy(nombre,rutaArchivo+(strlen(rutaArchivo)-(i-1)),i);
		 for(indice=0;nombre[indice]!='.'&&indice<strlen(nombre);indice++);
		 	// if(indice<strlen(nombre))
		 	//	 memcpy(nombre+indice," ",1);
		 	 int longfn=0,min,may;
		 	 for(i=0;nombre[i]!='.'&&i<strlen(nombre);i++)
		 		 if(0!=islower(nombre[i]))
		 			 break;
		 	 if(nombre[i]!='.'&&i<strlen(nombre)){
		 		 int j=0;
		 		 for(j=0;nombre[j]!='.';j++)
		 		 		 if(0==islower(nombre[j]))
		 		 			 break;
		 		 if(nombre[j]!='.'&&j<strlen(nombre))
		 			 longfn=1;
		 		 else{
		 			 min=1;may=0;
		 			 int h=i;
		 			 	 for(;i<strlen(nombre);i++)
		 			 		  if(0!=islower(nombre[i]))
		 			 		 			 break;
		 			 	 if(i<strlen(nombre)){
		 			 		for(;h<strlen(nombre);h++)
		 			 			 if(0==islower(nombre[h]))
		 			 			 	 break;
		 			 		 if(h<strlen(nombre))
		 			 			 longfn=1;
		 			 }
		 	 }
		 	 }
		 	 else{
		 		min=0;may=1;
		 		 int h=i;
		 	 for(;i<strlen(nombre);i++)
		 		  if(0!=islower(nombre[i]))
		 		 			 break;
		 	 if(i<strlen(nombre)){
		 		for(;h<strlen(nombre);h++)
		 			 if(0==islower(nombre[h]))
		 			 	 break;
		 		 if(h<strlen(nombre))
		 			 longfn=1;
		 	 }

		 	 }
	 for(indice=strlen(rutaArchivo);rutaArchivo[indice]!='/';indice--);
	 	 if(indice==0)
	 		 indice++;
	 char *rutaAnt=malloc(indice+1);

	 memcpy(rutaAnt,rutaArchivo,indice);

	 rutaAnt[indice]='\0';

	 if(!strcmp(rutaAnt,"/")){
		 dataLocal->numCluster=2;
		 buscarEntradaLibre(2,&sectorIni,&offset,longfn);
	 }

	 else{
		 int resultado=0;
		 resultado=buscarArchivo(rutaAnt,dataLocal);

		 if(resultado!=0){
	 		crearArchivoDirectorio(rutaAnt,dataLocal,modoApertura,1);
	 		buscarArchivo(rutaAnt,dataLocal);
		 }

		buscarEntradaLibre(dataLocal->numCluster,&sectorIni,&offset,longfn);
		free(rutaAnt);
	 }

	 if(creacion==1){
		 down(mutexFAT);
		 if(numClustersLibres>=1){
			 up(mutexFAT);

			 int rIO= buscar_Clusters_libres(1,&numCluster);

			 if(rIO!=0){
				 return -EIO;
			 }
			 else{
				 data->numCluster=numCluster;
				 grabar_FAT(data->numCluster,0xFFFFFFF);
			 }
		 }
		 else{
			 up(mutexFAT);
			 return -ENOSPC;
		 }

	 }
if(creacion==0)
	 data->numCluster=numCluster=0;
	 if(tamanioCache>0)

	 data->cacheArchivo= inicializarCache(nombre);

	 escribirEntradaDirectorio(sectorIni,offset,nombre,data,dataLocal->numCluster,longfn);

	return 0;
}

 /*____________________________________________________*/

 int escribirEntradaDirectorio(int sector,int offset,char*nombreArchivo,datosArchivo*data,int pCluster,int longfn){
	 char buffer[1024];
	 realizar_pedido_lectura(sector/2,buffer);
	 if(sector > sector/2 + sector/2){
		 offset+=512;
	 }
	 uint16_t vector[26];
	 memset(vector,0,26);
	 int tamanio=0;
	 unicode_utf8_to_utf16_inbuffer(nombreArchivo,strlen(nombreArchivo),vector,&tamanio);
	 int arch=0x20;
	 int dir=0x10;
	if(longfn==1) {
	 memset(buffer+offset,0,64);
	 memcpy(buffer+offset,"1",1);
	 if(tamanio>5){
		memset(buffer+offset+1,0,sizeof(uint16_t)*5);
		memcpy(buffer+offset+1,vector,sizeof(uint16_t)*5);
		if((tamanio-5)>6){
			memset(buffer+offset+0x0E,0,sizeof(uint16_t)*6);
			memcpy(buffer+offset+0x0E,vector+5,sizeof(uint16_t)*6);
			memset(buffer+offset+0x1C,0,sizeof(uint16_t)*2);
			memcpy(buffer+offset+0x1C,vector+5+6,sizeof(uint16_t)*2);
		}
		else{
			memset(buffer+offset+0x0E,0,sizeof(uint16_t)*(tamanio-5));
			memcpy(buffer+offset+0x0E,vector+5,sizeof(uint16_t)*(tamanio-5));
		}
	 }
	 else{
		 memset(buffer+offset+1,0,sizeof(uint16_t)*tamanio);
		 memcpy(buffer+offset+1,vector,sizeof(uint16_t)*tamanio);
	 }
	 int lfn = 0x0F;
	 memcpy(buffer+offset+11,&lfn,1);
	 if(strlen(nombreArchivo)>11){
		 memset(buffer+offset+32,0,11);
		 memcpy(buffer+offset+32,nombreArchivo,8);

		 int i;
		 for(i=0;i<strlen(nombreArchivo)&& nombreArchivo[i]!='.';i++);
			if(i<strlen(nombreArchivo))
				memcpy(buffer+offset+32+8,nombreArchivo+(strlen(nombreArchivo)-3),3);
	 }
	 else{
		  int i;
		  for(i=0;i<strlen(nombreArchivo)&& nombreArchivo[i]!='.';i++);
		  if(i<strlen(nombreArchivo)){
			  memcpy(buffer+offset+32,nombreArchivo,strlen(nombreArchivo)-3);
			  memcpy(buffer+offset+32+8,nombreArchivo+(strlen(nombreArchivo)-3),3);
		  }
		  else
			  memcpy(buffer+offset+32,nombreArchivo,strlen(nombreArchivo));
	 }


	 if(data->tipo==DIRECTORIO){
		 int offs=0;
		memcpy(buffer+offset+32+11,&(dir),1);
		int sectorDir= calcularPrimerSectorDelCluster(data->numCluster);
		char bufferDir[1024];
		realizar_pedido_lectura(sectorDir/2,bufferDir);
		if(sectorDir > sectorDir/2 + sectorDir/2)
			offs+=512;
		int punt=0x2E;
		memset(bufferDir+offs,0,64);
		memcpy(bufferDir+offs,&(punt),1);
		memcpy(bufferDir+11+offs,&(dir),1);
		memcpy(bufferDir+32+offs,&(punt),1);
		memcpy(bufferDir+32+1+offs,&(punt),1);
		memcpy(bufferDir+11+32+offs,&(dir),1);
		char vecAux[4];
		uint32_t num=pCluster;
		memset(vecAux,0,4);

		 	memcpy(vecAux,&num,sizeof(uint32_t));
		 	memcpy(bufferDir+32+0x1A+offs,vecAux,sizeof(uint16_t));
		 	memcpy(bufferDir+32+0x14+offs,vecAux+2,sizeof(uint16_t));



				 memset(vecAux,0,4);

			memcpy(vecAux,&data->numCluster,sizeof(uint32_t));
			memcpy(bufferDir+0x1A,vecAux,sizeof(uint16_t));
			memcpy(bufferDir+0x14,vecAux+2,sizeof(uint16_t));


		realizar_pedido_escritura(sectorDir/2,bufferDir);
	 }
	 else
		 memcpy(buffer+offset+32+11,&(arch),1);


		 memcpy(buffer+offset+32+0x1C,&(data->tamanioArchivo),sizeof(uint32_t));
	 char vecAux[4];

		 memset(vecAux,0,4);

		 memcpy(vecAux,&data->numCluster,sizeof(uint32_t));
		 memcpy(buffer+offset+32+0x1A,vecAux,sizeof(uint16_t));
		 memcpy(buffer+offset+32+0x14,vecAux+2,sizeof(uint16_t));


	 realizar_pedido_escritura(sector/2,buffer);
	}
	else{
			memset(buffer+offset,0,32);



					 int i;
					 for(i=0;i<strlen(nombreArchivo)&& nombreArchivo[i]!='.';i++);
						if(i<strlen(nombreArchivo))
							memcpy(buffer+offset+8,nombreArchivo+(strlen(nombreArchivo)-3),3);

						memcpy(buffer+offset,nombreArchivo,i);

				 if(data->tipo==DIRECTORIO){
					memcpy(buffer+offset+11,&(dir),1);
					int sectorDir= calcularPrimerSectorDelCluster(data->numCluster);
					char bufferDir[1024];
					realizar_pedido_lectura(sectorDir/2,bufferDir);
					int punt=0x2E;
					int offs=0;
					if(sectorDir > sectorDir/2 + sectorDir/2)
								offs+=512;
					memset(bufferDir+offs,0,64);
					memcpy(bufferDir+offs,&(punt),1);
					memcpy(bufferDir+11+offs,&(dir),1);
					memcpy(bufferDir+32+offs,&(punt),1);
					memcpy(bufferDir+32+1+offs,&(punt),1);
					memcpy(bufferDir+11+32+offs,&(dir),1);
					char vecAux[4];
					uint32_t num=pCluster;
					memset(vecAux,0,4);



					 	memcpy(vecAux,&num,sizeof(uint32_t));
					 	memcpy(bufferDir+32+0x1A+offs,vecAux,sizeof(uint16_t));
					 	memcpy(bufferDir+32+0x14+offs,vecAux+2,sizeof(uint16_t));



						memcpy(vecAux,&data->numCluster,sizeof(uint32_t));
						memcpy(bufferDir+0x1A+offs,vecAux,sizeof(uint16_t));
						memcpy(bufferDir+0x14+offs,vecAux+2,sizeof(uint16_t));


					realizar_pedido_escritura(sectorDir/2,bufferDir);
				 }
				 else
					 memcpy(buffer+offset+11,&(arch),1);


					 memcpy(buffer+offset+0x1C,&(data->tamanioArchivo),sizeof(uint32_t));
				 char vecAux[4];

					 memcpy(vecAux,&data->numCluster,sizeof(uint32_t));
					 memcpy(buffer+offset+0x1A,vecAux,sizeof(uint16_t));
					 memcpy(buffer+offset+0x14,vecAux+2,sizeof(uint16_t));


				 realizar_pedido_escritura(sector/2,buffer);


		}

	 return 0;


 }

 /*____________________________________________________*/

 int borrarEntradaDir(char*rutaArchivo){
	 int borrado=0xE5;
  	
	fat32_directory *directorio,*ptr=	NULL;
	char*vecAux;
	directorio=malloc(sizeof(fat32_directory));
	int pos=0,tamanioPath=0,posAnt=0,i;
	directorio->tipo=0;
	
	for(i=0;rutaArchivo[i]!='.'&&i<strlen(rutaArchivo);i++);

	//if(i<strlen(rutaArchivo))
	//	memcpy((rutaArchivo+i),".",1);
	tamanioPath=strlen(rutaArchivo);

	pos=strcspn(rutaArchivo,"/");
	posAnt=pos+1;
	leerDirectorio(directorio,FAT32.numClusterDirRoot);
	pos=strcspn(rutaArchivo+posAnt,"/");

	vecAux=malloc(sizeof(char)*pos);
	strncpy(vecAux,rutaArchivo+posAnt,pos);
    pos+=posAnt;
	
    if(directorio->tipo==0)
    	return 3;
    ptr=directorio;
	while(ptr!=NULL&&(strncmp(ptr->nombre,vecAux,pos-1))!=0)
		ptr=ptr->sig;

	free(vecAux);

	if(ptr==NULL)
		return 1;

	else{
			while(pos<tamanioPath){
				posAnt=pos+1;

				if(ptr->tipo!=DIRECTORIO)
					return 1; //no puede haber un dir en un archivo

				free(directorio);
				directorio=malloc(sizeof(fat32_directory));
				directorio->tipo=0;
				leerDirectorio(directorio,ptr->numClusterInicial);

				pos=strcspn(rutaArchivo+posAnt,"/");
				if(pos>tamanioPath)
					return 1; //falla el parseo
				vecAux=malloc(pos);
				strncpy(vecAux,rutaArchivo+posAnt,pos);
				
				if(directorio->tipo==0)
					return 3;
				ptr=directorio;
				while(ptr!=NULL&&(0!=strncmp(ptr->nombre,vecAux,pos)))
					ptr=ptr->sig;

				if(ptr==NULL)
					return 1;

				pos+=posAnt;
				free(vecAux);
			}
			if(ptr->tipo==0)
				return 3;
  			char bufferEscritura[1024];

  			realizar_pedido_lectura(ptr->numSectorEntrada/2,bufferEscritura);
  			if(ptr->numSectorEntrada>ptr->numSectorEntrada/2+ptr->numSectorEntrada/2)
  				ptr->offsetEntrada+=512;
  			if(ptr->LongFN==1){
  				memcpy(bufferEscritura+ptr->offsetEntrada,&borrado,sizeof(uint8_t));
  				memcpy(bufferEscritura+ptr->offsetEntrada+32,&borrado,sizeof(uint8_t));
  				realizar_pedido_escritura(ptr->numSectorEntrada/2,bufferEscritura);
  			}
  			else{
  				memcpy(bufferEscritura+ptr->offsetEntrada,&borrado,sizeof(uint8_t));
  				realizar_pedido_escritura(ptr->numSectorEntrada/2,bufferEscritura);
  			}
	}

  	return 0;
  }
